Bananas, Dark Worlds, and AspectH

This report summarises our idea of code clone detection in Haskell code and refactorings based on identified clones as it evolved in our group-of-three discussion. 1 Motivation Looking at the code example below, we observe a certain level of redundancy, in particular structural redundancy, such as pattern matching , if-then-elseconstructs, and recursion . addOdds :: Integral a => [a] -> a addOdds [] = 0 addOdds (h:t) = if odd h then h + (addOdds t) else addOdds t remNeg :: (Ord a, Num a) => [a] -> [a] remNeg [] = [] remNeg (h:t) = if h >= 0 then h : (remNeg t) else remNeg t getReflex :: Eq a => [(a,a)] -> [(a,a)] getReflex [] = [] getReflex ((x, y):t) = if (x == y) then (x, y) : (getReflex t) else getReflex t But how can we automate the process to find such recurring and somewhat redundant patterns? Should we investigate the source code directly, or is it better to find an intermediate representation, that abstracts the source code to a level where these patterns can be identified more easily, detached from the actual name of variables etc.? 1 Dagstuhl Seminar Proceedings 05451 Beyond Program Slicing http://drops.dagstuhl.de/opus/volltexte/2006/491 2 Functional Control Graph and Functional Control Tree As it would be very inconvenient to identify such redundancy by hand in the code, especially these structural similarities, we propose a special structure called functional control graph. Its entry node carries the name of the function, its other nodes each represent an expression from the Haskell code of that function. The edges can but may not necessarily be labeled: T (true)/F (false) for a step that requires the previous expression to be true/false, and parameter names in case any parameters are passed along. Considering the Haskell code example above, we get the following functional control graph for the function addOdds which takes a list of integers and returns the sum of all odd integers in that list: